程序员练级攻略：编程语言-[2026重制版]

// 指针 - C的灵魂
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 结构体和函数指针 - 回调机制
typedef struct {
    char name[64];
    int (*compare)(const void *, const void *);
} SortContext;

// 内存管理 - 手动分配释放
char* str_duplicate(const char* src) {
    if (src == NULL) return NULL;

    size_t len = strlen(src) + 1;
    char* dest = malloc(len);
    if (dest == NULL) return NULL;

    memcpy(dest, src, len);
    return dest;
}
// 使用后必须 free(dest)

// 所有权示例 - Rust的核心概念
fn main() {
    let s1 = String::from("hello");
    let s2 = s1;           // s1的所有权转移给s2
    // println!("{}", s1); // ❌ 编译错误！s1已失效
    println!("{}", s2);     // ✅ 正确

    // 克隆而非移动
    let s3 = String::from("world");
    let s4 = s3.clone();   // 深拷贝，两者都有效
    println!("{} {}", s3, s4);

    // 函数中的所有权规则
    let s5 = takes_ownership(s4);      // s4被移入函数
    let x = 5;
    makes_copy(x);                     // i32实现了Copy，x仍然有效
    println!("x = {}", x);

    // 引用与借用 - 不获取所有权
    let len = calculate_length(&s5);   // 传递引用
    println!("'{}' 的长度是 {}", s5, len); // s5仍然有效
}

fn takes_ownership(some_string: String) { // some_string进入作用域
    println!("{}", some_string);
} // some_string离开作用域，`drop`被调用，内存被释放

fn makes_copy(some_integer: i32) { // some_integer进入作用域
    println!("{}", some_integer);
} // some_integer离开作用域，没有特殊操作

fn calculate_length(s: &String) -> usize { // s是对String的引用
    s.length()
} // s离开作用域，但没有所有权，不会drop

package main

import (
    "fmt"
    "sync"
    "time"
)

// Worker Pool 模式
func worker(id int, jobs <-chan int, results chan<-int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second) // 模拟耗时任务
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    const numJobs = 10
    const numWorkers = 3

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    var wg sync.WaitGroup

    // 启动worker
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // 发送任务
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 等待所有worker完成
    go func() {
        wg.Wait()
        close(results)
    }()

    // 收集结果
    for r := range results {
        fmt.Println("Result:", r)
    }
}